.TH std::experimental::ranges::count,std::experimental::ranges::count_if 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::ranges::count,std::experimental::ranges::count_if \- std::experimental::ranges::count,std::experimental::ranges::count_if

.SH Synopsis
   Defined in header <experimental/ranges/algorithm>
   template< InputIterator I, Sentinel<I> S, class T, class Proj =
   ranges::identity >

       requires IndirectRelation<ranges::equal_to<>, projected<I,       \fB(1)\fP (ranges TS)
   Proj>, const T*>

   ranges::difference_type_t<I> count( I first, S last, const T& value,
   Proj proj = Proj{} );
   template< InputRange R, class T, class Proj = ranges::identity >

       requires IndirectRelation<ranges::equal_to<>,
                                 projected<ranges::iterator_t<R>,       \fB(2)\fP (ranges TS)
   Proj>, const T*>
   ranges::difference_type_t<ranges::iterator_t<R>>

       count( R&& r, const T& value, Proj proj = Proj{} );
   template< InputIterator I, Sentinel<I> S, class Proj =
   ranges::identity,

             IndirectUnaryPredicate<projected<I, Proj>> Pred >          \fB(3)\fP (ranges TS)

   ranges::difference_type_t<I> count_if( I first, S last, Pred pred,
   Proj proj = Proj{} );
   template< InputRange R, class Proj = ranges::identity,

             IndirectUnaryPredicate<projected<ranges::iterator_t<R>,
   Proj>> Pred >                                                        \fB(4)\fP (ranges TS)
   ranges::difference_type_t<ranges::iterator_t<R>>

       count_if( R&& r, Pred pred, Proj proj = Proj{} );

   Returns the number of elements in the range [first, last) satisfying specific
   criteria.

   1) Counts the elements whose projected values are equal to value (i.e.,
   ranges::invoke(proj, *i) == value).
   3) Counts the elements whose projected values satisfy the predicate pred (i.e.,
   ranges::invoke(pred, ranges::invoke(proj, *i)) != false).
   2,4) Same as (1,3), but uses r as the source range, as if using ranges::begin(r) as
   first and ranges::end(r) as last.

   Notwithstanding the declarations depicted above, the actual number and order of
   template parameters for algorithm declarations is unspecified. Thus, if explicit
   template arguments are used when calling an algorithm, the program is probably
   non-portable.

.SH Parameters

   first, last - the range of elements to examine
   r           - the range of elements to examine
   value       - the value to search for
   pred        - predicate to apply to the projected elements
   proj        - projection to apply to the elements

.SH Return value

   Number of elements satisfying the condition.

.SH Complexity

   Exactly last - first comparisons / applications of the predicate, and the same
   number of applications of the projection.

.SH Notes

   For the number of elements in the range [first, last) without any additional
   criteria, see ranges::distance.

.SH Possible implementation

.SH First version
   template<InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity>
       requires IndirectRelation<ranges::equal_to<>, projected<I, Proj>, const T*>
   ranges::difference_type_t<I> count(I first, S last, const T& value, Proj proj = Proj{})
   {
       ranges::difference_type_t<I> ret = 0;
       for (; first != last; ++first)
           if (ranges::invoke(proj, *first) == value)
               ++ret;
       return ret;
   }
.SH Second version
   template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
            IndirectUnaryPredicate<projected<I, Proj>> Pred>
   ranges::difference_type_t<I> count_if(I first, S last, Pred pred, Proj proj = Proj{})
   {
       ranges::difference_type_t<I> ret = 0;
       for (; first != last; ++first)
           if (ranges::invoke(pred, ranges::invoke(proj, *i)))
               ++ret;
       return ret;
   }

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   count    returns the number of elements satisfying specific criteria
   count_if \fI(function template)\fP
            returns the distance between an iterator and a sentinel, or between the
   distance beginning and the end of a range
            \fI(function template)\fP

.SH Category:
     * Todo no example
